home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 4 / FM Towns Free Software Collection 4 - Disc 1.iso / t_os / tie / src / event.c < prev    next >
C/C++ Source or Header  |  1991-10-18  |  11KB  |  487 lines
  1. /*
  2.     マウス イベント処理ライブラリ
  3.  
  4.     1990.9.11   Make By ken
  5. */
  6.  
  7. #include    <stdio.h>
  8. #include    <stdlib.h>
  9. #include    <egb.h>
  10. #include    <mos.h>
  11. #include    <msdos.cf>
  12. #include    <snd.h>
  13. #include    "tie.h"
  14.  
  15. #define MAX_EVENT   256
  16. #define MAX_EVT     16
  17.  
  18. static  int     enable_cancel = TRUE ;
  19. static  int     enable_ground = TRUE ;
  20. static  int     evt_max = 0 ;
  21. static  int     evt_free = ERR ;
  22. static  int     last_node = ERR ;
  23. static  int     max_cancel = 0 ;
  24. static  int     max_ground = 0 ;
  25. static  EVENT   evt_node[ MAX_EVENT ] ;
  26. static  EVT     cancel[ MAX_EVT ] ;
  27. static  EVT     ground[ MAX_EVT ] ;
  28.  
  29. extern  int     EVT_get_node( void ) ;
  30. extern  void    EVT_free_node( int ) ;
  31. extern  int     EVT_chk( EVENT *, int, int, int ) ;
  32. extern  EVT     *EVT_chk_cancel( int, int ) ;
  33. extern  EVT     *EVT_chk_ground( int, int ) ;
  34.  
  35. #define padU(x) ( ((x) & 0x01) == 0 ? TRUE : FALSE )
  36. #define padD(x) ( ((x) & 0x02) == 0 ? TRUE : FALSE )
  37. #define padL(x) ( ((x) & 0x04) == 0 ? TRUE : FALSE )
  38. #define padR(x) ( ((x) & 0x08) == 0 ? TRUE : FALSE )
  39. #define padA(x) ( ((x) & 0x10) == 0 ? TRUE : FALSE )
  40. #define padB(x) ( ((x) & 0x20) == 0 ? TRUE : FALSE )
  41.  
  42.  
  43. /*  マウスとパッドを区別せず扱う位置情報取得ルーチン  */
  44.  
  45. /*  マウスとパッドを区別せず扱う位置情報取得ルーチン  */
  46.  
  47. void    MOS_PAD_rdpos( int *sw, int *x, int *y )
  48. {
  49.     static  int     pad_num = 0 ;
  50.     static  int     count = 0 ;
  51.     auto    int     pad, dt, dx, dy ;
  52.  
  53.     /*  マウスカーソルの位置を読み込む  */
  54.     MOS_rdpos( sw, x, y ) ;
  55.  
  56.     /*  パッドによる制御  */
  57.     SND_joy_in_1( 0, &pad ) ;
  58.  
  59.     if( 0x3F != pad )       /*  どれかON  */
  60.     {
  61.         *sw = ( padB( pad ) ? 2 : 0 ) | ( padA( pad ) ? 1 : 0 ) ;
  62.  
  63.         if( count ++ >= 10 )
  64.         {
  65.             count = 0 ;
  66.  
  67.             if( ( dt = pad_num / 5 ) < 1 ) dt = 1 ;
  68.             if( dt > 16 )                  dt = 16 ;
  69.  
  70.             dx = dy = 0 ;
  71.  
  72.             if( !padL( pad ) || !padR( pad ) )
  73.                 dx = ( padL( pad ) ? (- dt) : ( padR( pad ) ? dt : 0 ) ) ;
  74.             if( !padU( pad ) || !padD( pad ) )
  75.                 dy = ( padU( pad ) ? (- dt) : ( padD( pad ) ? dt : 0 ) ) ;
  76.  
  77.             if( dx != 0 || dy != 0 )
  78.                 MOS_setpos( *x += dx, *y += dy ) ;
  79.             pad_num ++ ;
  80.         }
  81.     }
  82.     else
  83.         pad_num = 0 ;
  84. }
  85.  
  86.  
  87. /*  イベント待ちループ  */
  88.  
  89. void    EVT_loop( int min_level, int max_level )
  90. {
  91.     REGS    EVENT   *ep ;
  92.     auto    int     i, sw, x, y ;
  93.     static  int     r_on = FALSE ;
  94.  
  95.     MOS_PAD_rdpos( &sw, &x, &y ) ;
  96.  
  97.     /*  右クリックによるキャンセル機能  */
  98.     if( enable_cancel != FALSE )
  99.     {
  100.         if( max_cancel > 0 )
  101.         {
  102.             if( r_on == TRUE && rbtn( sw ) == FALSE )
  103.                 EVT_chk_cancel( min_level, max_level ) ;
  104.  
  105.             r_on = rbtn( sw ) ;
  106.         }
  107.         sw &= 1 ;
  108.     }
  109.  
  110.     if( last_node != ERR )
  111.     {
  112.         ep = &( evt_node[last_node] ) ;
  113.         if( ep->flg != FALSE &&
  114.                 ep->level >= min_level && ep->level <= max_level &&
  115.                 EVT_chk( ep, x, y, sw ) != EVT_NON )
  116.             return ;
  117.     }
  118.  
  119.     last_node = ERR ;
  120.  
  121.     for( i = 0 ; i < evt_max ; i++ )
  122.     {
  123.         ep = &( evt_node[i] ) ;
  124.         if( ep->flg != FALSE &&
  125.             ep->level >= min_level && ep->level <= max_level &&
  126.             EVT_chk( ep, x, y, sw ) != EVT_NON )
  127.         {
  128.             last_node = i ;
  129.             return ;
  130.         }
  131.     }
  132.  
  133.     /*  余白のクリックによるイベント  */
  134.     if( enable_ground != FALSE )
  135.     {
  136.         if( max_ground > 0 )
  137.         {
  138.             if( r_on == TRUE && rbtn( sw ) == FALSE )
  139.                 EVT_chk_ground( min_level, max_level ) ;
  140.             r_on = rbtn( sw ) ;
  141.         }
  142.     }
  143. }
  144.  
  145. int     lbtn( int sw )  /*  左ボタンが押されていたら、TRUE  */
  146. {
  147.     return( ( sw & 1 ) != 0 ? TRUE : FALSE ) ;
  148. }
  149. int     rbtn( int sw )  /*  右ボタンが押されていたら、TRUE  */
  150. {
  151.     return( ( sw & 2 ) != 0 ? TRUE : FALSE ) ;
  152. }
  153.  
  154. void    EVT_control_cancel( int flag )
  155. {
  156.     enable_cancel = flag ;
  157. }
  158.  
  159. void    EVT_control_ground( int flag )
  160. {
  161.     enable_ground = flag ;
  162. }
  163.  
  164. static  EVT     *EVT_chk_cancel( int min, int max )
  165. {
  166.     REGS    int     i ;
  167.     REGS    EVT     *cp ;
  168.  
  169.     for( i = 0 ; i < max_cancel ; i ++ )
  170.     {
  171.         cp = &cancel[i] ;
  172.  
  173.         if( cp->flg == TRUE && cp->level >= min && cp->level <= max )
  174.         {
  175.             (*cp->proc)() ;
  176.             return cp ;
  177.         }
  178.     }
  179.     return NULL ;
  180. }
  181.  
  182. static  EVT     *EVT_chk_ground( int min, int max )
  183. {
  184.     REGS    int     i ;
  185.     REGS    EVT     *cp ;
  186.  
  187.     for( i = 0 ; i < max_ground ; i ++ )
  188.     {
  189.         cp = &ground[i] ;
  190.  
  191.         if( cp->flg == TRUE && cp->level >= min && cp->level <= max )
  192.         {
  193.             (*cp->proc)() ;
  194.             return cp ;
  195.         }
  196.     }
  197.     return NULL ;
  198. }
  199.  
  200.  
  201. /*  イベントの発生をチェック  */
  202.  
  203. static  int     EVT_chk( REGS EVENT *ep, int x, int y, int sw )
  204. {
  205.     auto    int     on ;
  206.  
  207.     on = ( x >= ep->x1 && x <= ep->x2 && 
  208.            y >= ep->y1 && y <= ep->y2 ) ? TRUE : FALSE ;
  209.  
  210.     switch( ep->now )
  211.     {
  212.       case EVT_OFF_MOS:
  213.       case EVT_MOVE_MOS:
  214.       case EVT_DLSEL_MOS:
  215.       case EVT_SELECT_MOS:
  216.         ep->now = EVT_NON ;
  217.         break ;
  218.  
  219.       case EVT_NON:
  220.         if( on == TRUE )
  221.         {
  222.             ep->now = ( sw != 0 ? EVT_CLIP_MOS:EVT_ON_MOS ) ;
  223.             (*ep->proc)( ep, x, y, sw ) ;
  224.         }
  225.         break ;
  226.  
  227.       case EVT_ON_MOS:
  228.         if( on == TRUE )
  229.         {
  230.             ep->now = ( sw != 0 ? EVT_CLIP_MOS : EVT_ON_MOS ) ;
  231.             (*ep->proc)( ep, x, y, sw ) ; 
  232.         }
  233.         else
  234.         {
  235.             ep->now = EVT_OFF_MOS ;
  236.             (*ep->proc)( ep, x, y, sw ) ;
  237.         }
  238.         break ;
  239.  
  240.       case EVT_CLIP_MOS:
  241.         if( on == TRUE )
  242.         {
  243.             if( sw == 0 )   /*  ボタンを離した  */
  244.             {
  245.                 ep->now = EVT_SELECT_MOS ;
  246.                 (*ep->proc)( ep, x, y, sw ) ;
  247.             }
  248.         }
  249.         else
  250.         {
  251.             ep->now = ( sw != 0 ? EVT_DOLACK_MOS : EVT_MOVE_MOS ) ;
  252.             (*ep->proc)( ep, x, y, sw ) ;
  253.         }
  254.         break ;
  255.  
  256.       case EVT_DOLACK_MOS:
  257.         if( sw == 0 )       /*  ボタンを離した  */
  258.         {
  259.             ep->now = EVT_DLSEL_MOS ;
  260.             (*ep->proc)( ep, x, y, sw ) ;
  261.         }
  262.         else
  263.         {
  264.             ep->now = EVT_DOLACK_MOS ;
  265.             (*ep->proc)( ep, x, y, sw ) ;
  266.         }
  267.         break ;
  268.  
  269.       case EVT_REP_MOS:
  270.         if( on == TRUE )
  271.         {
  272.             if( sw == 0 )   /*  ボタンを離した  */
  273.             {
  274.                 ep->now = EVT_SELECT_MOS ;
  275.                 (*ep->proc)( ep, x, y, sw ) ;
  276.             }
  277.             else
  278.                 (*ep->proc)( ep, x, y, sw ) ;
  279.         }
  280.         else
  281.         {
  282.             ep->now = ( sw == 0 ? EVT_DOLACK_MOS : EVT_MOVE_MOS ) ;
  283.             (*ep->proc)( ep, x, y, sw ) ;
  284.         }
  285.         break ;
  286.     }
  287.  
  288.     return ep->now ;
  289. }
  290.  
  291. static  int     EVT_get_node( void )
  292. {
  293.     auto    int     no ;
  294.  
  295.     if( ( no = evt_free ) != ERR )
  296.         evt_free = evt_node[ evt_free ].level ;
  297.     else if( evt_max >= MAX_EVENT )
  298.         return ERR ;
  299.     else
  300.         no = evt_max ++ ;
  301.  
  302.     return no ;
  303. }
  304.  
  305. static  void    EVT_free_node( int no )
  306. {
  307.     evt_node[ no ].flg = FALSE ;
  308.     evt_node[ no ].level = evt_free ;
  309.     evt_free = no ;
  310.     if( no == last_node )
  311.         last_node = ERR ;
  312. }
  313.  
  314. void    EVT_level_free( int level )
  315. {
  316.     auto    int     i ;
  317.     REGS    EVENT   *ep ;
  318.     REGS    EVT     *cp ;
  319.  
  320.     for( i = 0 ; i < MAX_EVENT ; i ++ )
  321.     {
  322.         ep = &( evt_node[ i ] ) ;
  323.         if( ep->flg != FALSE && ep->level == level )
  324.             EVT_free_node( i ) ;
  325.     }
  326.  
  327.     for( i = 0 ; i < MAX_EVT ; i ++ )
  328.     {
  329.         cp = &( cancel[ i ] ) ;
  330.         if( cp->flg != FALSE && cp->level == level )
  331.             cp->flg = FALSE ;
  332.  
  333.         cp = &( ground[ i ] ) ;
  334.         if( cp->flg != FALSE && cp->level == level )
  335.             cp->flg = FALSE ;
  336.     }
  337. }
  338.  
  339. EVENT   *EVT_set_node( int x1, int y1, int x2, int y2,
  340.                            int level, void (*proc)(), int no, int rep )
  341. {
  342.     auto    int     node ;
  343.     REGS    EVENT   *ep ;
  344.  
  345.     if( ( node = EVT_get_node() ) == ERR )
  346.         return NULL ;
  347.  
  348.     ep = &( evt_node[ node ] ) ;
  349.     ep->flg = TRUE ;
  350.     ep->level = level ;
  351.     ep->now = 0 ;
  352.     ep->no = no ;
  353.     ep->x1 = x1 ;
  354.     ep->y1 = y1 ;
  355.     ep->x2 = x2 ;
  356.     ep->y2 = y2 ;
  357.     ep->rep = rep ;
  358.     ep->proc = proc ;
  359.  
  360.     return ep ;
  361. }
  362.  
  363. EVT     *EVT_set_cancel( int level, void (*proc)() )
  364. {
  365.     REGS    int     i ;
  366.     auto    EVT     *cp ;
  367.  
  368.     if( max_cancel < MAX_EVT )
  369.         cp = &cancel[ max_cancel ++ ] ;
  370.     else
  371.     {
  372.         for( i = 0 ; i < MAX_EVT ; i ++ )
  373.             if( cancel[i].flg == FALSE )
  374.             {
  375.                 cp = &cancel[ i ] ;
  376.                 break ;
  377.             }
  378.         if( i == MAX_EVT )
  379.             return( NULL ) ;
  380.     }
  381.  
  382.     cp->flg = TRUE ;
  383.     cp->level = level ;
  384.     cp->proc = proc ;
  385.  
  386.     return cp ;
  387. }
  388.  
  389. void    EVT_unset_cancel( int level )
  390. {
  391.     REGS    int     i ;
  392.     REGS    EVT     *cp ;
  393.  
  394.     for( i = 0 ; i < MAX_EVT ; i ++ )
  395.     {
  396.         cp = &( cancel[ i ] ) ;
  397.         if( cp->flg != FALSE && cp->level == level )
  398.             cp->flg = FALSE ;
  399.     }
  400. }
  401.  
  402. EVT     *EVT_set_ground( int level, void (*proc)() )
  403. {
  404.     REGS    int     i ;
  405.     auto    EVT     *cp ;
  406.  
  407.     if( max_ground < MAX_EVT )
  408.         cp = &ground[ max_ground ++ ] ;
  409.     else
  410.     {
  411.         for( i = 0 ; i < MAX_EVT ; i ++ )
  412.             if( ground[i].flg == FALSE )
  413.             {
  414.                 cp = &ground[ i ] ;
  415.                 break ;
  416.             }
  417.         if( i == MAX_EVT )
  418.             return( NULL ) ;
  419.     }
  420.  
  421.     cp->flg = TRUE ;
  422.     cp->level = level ;
  423.     cp->proc = proc ;
  424.  
  425.     return cp ;
  426. }
  427.  
  428. void    EVT_unset_ground( int level )
  429. {
  430.     REGS    int     i ;
  431.     REGS    EVT     *cp ;
  432.  
  433.     for( i = 0 ; i < MAX_EVT ; i ++ )
  434.     {
  435.         cp = &( ground[ i ] ) ;
  436.         if( cp->flg != FALSE && cp->level == level )
  437.             cp->flg = FALSE ;
  438.     }
  439. }
  440.  
  441. void    EVT_reset( void )
  442. {
  443.     int     i ;
  444.  
  445.     evt_max = 0 ;
  446.     evt_free = ERR ;
  447.     last_node = ERR ;
  448.     max_cancel = 0 ;
  449.  
  450.     for( i = 0 ; i < MAX_EVENT ; i ++ )
  451.     {
  452.         evt_node[ i ].flg = FALSE ;
  453.         evt_node[ i ].level = 0 ;
  454.     }
  455.     for( i = 0 ; i < MAX_EVT ; i ++ )
  456.     {
  457.         cancel[ i ].flg   = ground[ i ].flg   = FALSE ;
  458.         cancel[ i ].level = ground[ i ].level = 0 ;
  459.     }
  460. }
  461. /*
  462.  
  463. #define XPOS    64
  464. #define YPOS    50
  465. #define XNUM    32
  466. #define YNUM    ((MAX_EVENT/XNUM)+3)
  467. #define XP      16
  468. #define YP      20
  469.  
  470. void    EVT_print_list( void )
  471. {
  472.     int     i ;
  473.     char    tmp[128] ;
  474.  
  475.     dsp_box( XPOS-8,YPOS, XPOS+XNUM*XP, YPOS+YP*YNUM, 5,5,5 ) ;
  476.     dsp_box( XPOS-6,YPOS+2, XPOS+XNUM*XP-2, YPOS+YP*YNUM-2, 7,8,5 ) ;
  477.  
  478.     sprintf( tmp, "MAX_EVENT:%d  evt_max:%3d  evt_free:%3d",
  479.                                         MAX_EVENT, evt_max, evt_free ) ;
  480.     wrt( tmp, writepage, XPOS+32,YPOS+8, COL_15,COL_5, 16 ) ;
  481.  
  482.     for( i = 0 ; i < MAX_EVENT ; i++ )
  483.         wrt( evt_node[i].flg ? "*" : ".", writepage,
  484.             XPOS+(i%XNUM)*XP,YPOS+YP*2+(i/XNUM)*YP, COL_15,COL_5, 16 ) ;
  485. }
  486. */
  487.